/**
 * 表单验证工具类
 */

/**
 * 验证手机号格式
 * @param {string} phone 手机号
 * @returns {boolean} 是否有效
 */
export function validatePhone(phone) {
	const phoneRegex = /^1[3-9]\d{9}$/
	return phoneRegex.test(phone)
}

/**
 * 验证验证码格式
 * @param {string} code 验证码
 * @param {number} length 验证码长度，默认6位
 * @returns {boolean} 是否有效
 */
export function validateVerifyCode(code, length = 6) {
	if (!code) return false
	return code.length === length && /^\d+$/.test(code)
}

/**
 * 验证身份证号格式
 * @param {string} idCard 身份证号
 * @returns {boolean} 是否有效
 */
export function validateIdCard(idCard) {
	const reg = /(^\d{15}$)|(^\d{18}$)|(^\d{17}(\d|X|x)$)/
	return reg.test(idCard)
}

/**
 * 验证邮箱格式
 * @param {string} email 邮箱
 * @returns {boolean} 是否有效
 */
export function validateEmail(email) {
	const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
	return emailRegex.test(email)
}

/**
 * 验证密码强度
 * @param {string} password 密码
 * @param {object} options 验证选项
 * @returns {object} 验证结果
 */
export function validatePassword(password, options = {}) {
	const {
		minLength = 6,
		maxLength = 20,
		requireNumber = false,
		requireLetter = false,
		requireSpecial = false
	} = options

	const result = {
		valid: true,
		errors: []
	}

	if (!password) {
		result.valid = false
		result.errors.push('密码不能为空')
		return result
	}

	if (password.length < minLength) {
		result.valid = false
		result.errors.push(`密码长度不能少于${minLength}位`)
	}

	if (password.length > maxLength) {
		result.valid = false
		result.errors.push(`密码长度不能超过${maxLength}位`)
	}

	if (requireNumber && !/\d/.test(password)) {
		result.valid = false
		result.errors.push('密码必须包含数字')
	}

	if (requireLetter && !/[a-zA-Z]/.test(password)) {
		result.valid = false
		result.errors.push('密码必须包含字母')
	}

	if (requireSpecial && !/[!@#$%^&*(),.?":{}|<>]/.test(password)) {
		result.valid = false
		result.errors.push('密码必须包含特殊字符')
	}

	return result
}

/**
 * 验证姓名格式
 * @param {string} name 姓名
 * @returns {boolean} 是否有效
 */
export function validateName(name) {
	if (!name || !name.trim()) return false
	// 中文姓名：2-10个中文字符
	// 英文姓名：2-20个英文字符和空格
	const chineseNameRegex = /^[\u4e00-\u9fa5]{2,10}$/
	const englishNameRegex = /^[a-zA-Z\s]{2,20}$/
	return chineseNameRegex.test(name) || englishNameRegex.test(name)
}

/**
 * 手机号脱敏显示
 * @param {string} phone 手机号
 * @returns {string} 脱敏后的手机号
 */
export function maskPhone(phone) {
	if (!phone) return ''
	return phone.replace(/(\d{3})\d{4}(\d{4})/, '$1****$2')
}

/**
 * 身份证号脱敏显示
 * @param {string} idCard 身份证号
 * @returns {string} 脱敏后的身份证号
 */
export function maskIdCard(idCard) {
	if (!idCard) return ''
	if (idCard.length === 15) {
		return idCard.replace(/(\d{6})\d{6}(\d{3})/, '$1******$2')
	} else if (idCard.length === 18) {
		return idCard.replace(/(\d{6})\d{8}(\d{4})/, '$1********$2')
	}
	return idCard
}

/**
 * 邮箱脱敏显示
 * @param {string} email 邮箱
 * @returns {string} 脱敏后的邮箱
 */
export function maskEmail(email) {
	if (!email) return ''
	const [username, domain] = email.split('@')
	if (!username || !domain) return email
	
	if (username.length <= 3) {
		return `${username.charAt(0)}***@${domain}`
	} else {
		return `${username.substring(0, 3)}***@${domain}`
	}
}

/**
 * 表单验证器类
 */
export class FormValidator {
	constructor() {
		this.rules = {}
		this.errors = {}
	}

	/**
	 * 添加验证规则
	 * @param {string} field 字段名
	 * @param {array} rules 验证规则数组
	 */
	addRule(field, rules) {
		this.rules[field] = rules
	}

	/**
	 * 验证单个字段
	 * @param {string} field 字段名
	 * @param {any} value 字段值
	 * @returns {boolean} 是否通过验证
	 */
	validateField(field, value) {
		const rules = this.rules[field]
		if (!rules) return true

		this.errors[field] = []

		for (const rule of rules) {
			if (rule.required && (!value || value.toString().trim() === '')) {
				this.errors[field].push(rule.message || `${field}不能为空`)
				continue
			}

			if (rule.validator && typeof rule.validator === 'function') {
				const result = rule.validator(value)
				if (!result) {
					this.errors[field].push(rule.message || `${field}格式不正确`)
				}
			}

			if (rule.pattern && !rule.pattern.test(value)) {
				this.errors[field].push(rule.message || `${field}格式不正确`)
			}

			if (rule.min && value.length < rule.min) {
				this.errors[field].push(rule.message || `${field}长度不能少于${rule.min}位`)
			}

			if (rule.max && value.length > rule.max) {
				this.errors[field].push(rule.message || `${field}长度不能超过${rule.max}位`)
			}
		}

		return this.errors[field].length === 0
	}

	/**
	 * 验证所有字段
	 * @param {object} data 表单数据
	 * @returns {boolean} 是否通过验证
	 */
	validate(data) {
		let isValid = true
		this.errors = {}

		for (const field in this.rules) {
			const fieldValid = this.validateField(field, data[field])
			if (!fieldValid) {
				isValid = false
			}
		}

		return isValid
	}

	/**
	 * 获取字段错误信息
	 * @param {string} field 字段名
	 * @returns {string} 错误信息
	 */
	getError(field) {
		return this.errors[field] && this.errors[field].length > 0 ? this.errors[field][0] : ''
	}

	/**
	 * 获取所有错误信息
	 * @returns {object} 所有错误信息
	 */
	getErrors() {
		const result = {}
		for (const field in this.errors) {
			result[field] = this.getError(field)
		}
		return result
	}

	/**
	 * 清除错误信息
	 * @param {string} field 字段名，不传则清除所有
	 */
	clearErrors(field) {
		if (field) {
			delete this.errors[field]
		} else {
			this.errors = {}
		}
	}
}

// 常用验证规则预设
export const commonRules = {
	phone: [
		{ required: true, message: '请输入手机号' },
		{ validator: validatePhone, message: '请输入正确的手机号格式' }
	],
	verifyCode: [
		{ required: true, message: '请输入验证码' },
		{ validator: (value) => validateVerifyCode(value, 6), message: '验证码为6位数字' }
	],
	password: [
		{ required: true, message: '请输入密码' },
		{ min: 6, message: '密码长度不能少于6位' },
		{ max: 20, message: '密码长度不能超过20位' }
	],
	name: [
		{ required: true, message: '请输入姓名' },
		{ validator: validateName, message: '请输入正确的姓名格式' }
	],
	email: [
		{ validator: validateEmail, message: '请输入正确的邮箱格式' }
	],
	idCard: [
		{ required: true, message: '请输入身份证号' },
		{ validator: validateIdCard, message: '请输入正确的身份证号格式' }
	]
}
